/*******************************************************************************
* Copyright (c) 2000, 2013 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ant.tests.ui.debug;
import org.eclipse.ant.internal.launching.debug.model.AntDebugTarget;
import org.eclipse.ant.internal.launching.debug.model.AntLineBreakpoint;
import org.eclipse.ant.internal.launching.debug.model.AntStackFrame;
import org.eclipse.ant.internal.launching.debug.model.AntThread;
import org.eclipse.ant.tests.ui.AbstractAntUIBuildTest;
import org.eclipse.ant.tests.ui.testplugin.DebugElementKindEventWaiter;
import org.eclipse.ant.tests.ui.testplugin.DebugEventWaiter;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IBreakpointManager;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IBreakpoint;
import org.eclipse.debug.core.model.ILineBreakpoint;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.model.IThread;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.preferences.IDebugPreferenceConstants;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.BadPositionCategoryException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.console.IHyperlink;
import org.eclipse.ui.internal.console.ConsoleHyperlinkPosition;
/**
* Tests for launch configurations
*/
public abstract class AbstractAntDebugTest extends AbstractAntUIBuildTest {
public static final int DEFAULT_TIMEOUT = 20000;
/**
* The last relevant event set - for example, that caused a thread to suspend
*/
protected DebugEvent[] fEventSet;
public AbstractAntDebugTest(String name) {
super(name);
// set error dialog to non-blocking to avoid hanging the UI during test
ErrorDialog.AUTOMATED_MODE = true;
SafeRunnable.setIgnoreErrors(true);
}
/**
* Sets the last relevant event set
*
* @param set
* event set
*/
protected void setEventSet(DebugEvent[] set) {
fEventSet = set;
}
/**
* Returns the last relevant event set
*
* @return event set
*/
protected DebugEvent[] getEventSet() {
return fEventSet;
}
/**
* Returns the breakpoint manager
*
* @return breakpoint manager
*/
protected IBreakpointManager getBreakpointManager() {
return DebugPlugin.getDefault().getBreakpointManager();
}
/**
* Returns the source folder with the given name in the given project.
*
* @param project
* @param name
* source folder name
* @return package fragment root
*/
protected IPackageFragmentRoot getPackageFragmentRoot(IJavaProject project, String name) {
IProject p = project.getProject();
return project.getPackageFragmentRoot(p.getFolder(name));
}
@Override
protected IHyperlink getHyperlink(int offset, IDocument doc) {
if (offset >= 0 && doc != null) {
Position[] positions = null;
try {
positions = doc.getPositions(ConsoleHyperlinkPosition.HYPER_LINK_CATEGORY);
}
catch (BadPositionCategoryException ex) {
// no links have been added
return null;
}
for (int i = 0; i < positions.length; i++) {
Position position = positions[i];
if (offset >= position.getOffset() && offset <= (position.getOffset() + position.getLength())) {
return ((ConsoleHyperlinkPosition) position).getHyperLink();
}
}
}
return null;
}
/**
* Launches the given configuration and waits for an event. Returns the source of the event. If the event is not received, the launch is
* terminated and an exception is thrown.
*
* @param configuration
* the configuration to launch
* @param waiter
* the event waiter to use
* @return Object the source of the event
* @exception Exception
* if the event is never received.
*/
@Override
protected Object launchAndWait(ILaunchConfiguration configuration, DebugEventWaiter waiter) throws CoreException {
return launchAndWait(configuration, waiter, true);
}
/**
* Launches the given configuration and waits for an event. Returns the source of the event. If the event is not received, the launch is
* terminated and an exception is thrown.
*
* @param configuration
* the configuration to launch
* @param waiter
* the event waiter to use
* @param register
* whether to register the launch
* @return Object the source of the event
* @exception Exception
* if the event is never received.
*/
protected Object launchAndWait(ILaunchConfiguration configuration, DebugEventWaiter waiter, boolean register) throws CoreException {
ILaunch launch = configuration.launch(ILaunchManager.DEBUG_MODE, null, false, register);
Object suspendee = waiter.waitForEvent();
if (suspendee == null) {
try {
launch.terminate();
}
catch (CoreException e) {
e.printStackTrace();
fail("Program did not suspend, and unable to terminate launch."); //$NON-NLS-1$
}
}
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend, launch terminated"); //$NON-NLS-1$
}
return suspendee;
}
/**
* Launches the build file with the given name, and waits for a suspend event in that program. Returns the thread in which the suspend event
* occurred.
*
* @param buildFileName
* the build file to launch
* @return thread in which the first suspend event occurred
*/
protected AntThread launchAndSuspend(String buildFileName) throws Exception {
ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
return launchAndSuspend(config);
}
/**
* Launches the given configuration in debug mode, and waits for a suspend event in that program. Returns the thread in which the suspend event
* occurred.
*
* @param config
* the configuration to launch
* @return thread in which the first suspend event occurred
*/
protected AntThread launchAndSuspend(ILaunchConfiguration config) throws Exception {
DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
waiter.setTimeout(DEFAULT_TIMEOUT);
Object suspendee = launchAndWait(config, waiter);
return (AntThread) suspendee;
}
/**
* Launches the build file with the given name, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which the
* suspend event occurred.
*
* @param buildFileName
* the build file to launch
* @return thread in which the first suspend event occurred
*/
protected AntThread launchToBreakpoint(String buildFileName) throws Exception {
return launchToBreakpoint(buildFileName, true, false);
}
/**
* Launches the build file with the given name in a separate VM, and waits for a breakpoint-caused suspend event in that program. Returns the
* thread in which the suspend event occurred.
*
* @param buildFileName
* the build file to launch
* @return thread in which the first suspend event occurred
*/
protected AntThread launchToBreakpointSepVM(String buildFileName) throws Exception {
return launchToBreakpoint(buildFileName, true, true);
}
/**
* Launches the build file with the given name, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which the
* suspend event occurred.
*
* @param buildFileName
* the build file to launch
* @param register
* whether to register the launch
* @return thread in which the first suspend event occurred
*/
protected AntThread launchToBreakpoint(String buildFileName, boolean register, boolean sepVM) throws Exception {
if (sepVM) {
buildFileName += "SepVM"; //$NON-NLS-1$
}
ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
return launchToBreakpoint(config, register);
}
/**
* Launches the given configuration in debug mode, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which
* the suspend event occurred.
*
* @param config
* the configuration to launch
* @return thread in which the first suspend event occurred
*/
protected AntThread launchToBreakpoint(ILaunchConfiguration config) throws CoreException {
return launchToBreakpoint(config, true);
}
/**
* Launches the given configuration in debug mode, and waits for a breakpoint-caused suspend event in that program. Returns the thread in which
* the suspend event occurred.
*
* @param config
* the configuration to launch
* @param whether
* to register the launch
* @return thread in which the first suspend event occurred
*/
protected AntThread launchToBreakpoint(ILaunchConfiguration config, boolean register) throws CoreException {
DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
waiter.setTimeout(DEFAULT_TIMEOUT);
Object suspendee = launchAndWait(config, waiter, register);
assertTrue("suspendee was not an AntThread", suspendee instanceof AntThread); //$NON-NLS-1$
return (AntThread) suspendee;
}
/**
* Launches the build file with the given name, and waits for a terminate event in that program. Returns the debug target in which the suspend
* event occurred.
*
* @param buildFileName
* the build file to execute
* @return debug target in which the terminate event occurred
*/
protected AntDebugTarget launchAndTerminate(String buildFileName) throws Exception {
return launchAndTerminate(buildFileName, false);
}
protected AntDebugTarget launchAndTerminate(String buildFileName, boolean sepVM) throws Exception {
if (sepVM) {
buildFileName += "SepVM"; //$NON-NLS-1$
}
ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
return debugLaunchAndTerminate(config, DEFAULT_TIMEOUT);
}
/**
* Launches the given configuration in debug mode, and waits for a terminate event in that program. Returns the debug target in which the
* terminate event occurred.
*
* @param config
* the configuration to launch
* @param timeout
* the number of milliseconds to wait for a terminate event
* @return thread in which the first suspend event occurred
*/
protected AntDebugTarget debugLaunchAndTerminate(ILaunchConfiguration config, int timeout) throws Exception {
DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.TERMINATE, AntDebugTarget.class);
waiter.setTimeout(timeout);
Object terminatee = launchAndWait(config, waiter);
assertNotNull("Program did not terminate.", terminatee); //$NON-NLS-1$
assertTrue("terminatee is not an AntDebugTarget", terminatee instanceof AntDebugTarget); //$NON-NLS-1$
AntDebugTarget debugTarget = (AntDebugTarget) terminatee;
assertTrue("debug target is not terminated", debugTarget.isTerminated() || debugTarget.isDisconnected()); //$NON-NLS-1$
return debugTarget;
}
/**
* Launches the build file with the given name, and waits for a line breakpoint suspend event in that program. Returns the thread in which the
* suspend event occurred.
*
* @param buildFileName
* the build file to execute
* @param bp
* the breakpoint that should cause a suspend event
* @return thread in which the first suspend event occurred
* @throws CoreException
*/
protected AntThread launchToLineBreakpoint(String buildFileName, ILineBreakpoint bp) throws CoreException {
ILaunchConfiguration config = getLaunchConfiguration(buildFileName);
assertNotNull("Could not locate launch configuration for " + buildFileName, config); //$NON-NLS-1$
return launchToLineBreakpoint(config, bp);
}
/**
* Launches the given configuration in debug mode, and waits for a line breakpoint suspend event in that program. Returns the thread in which the
* suspend event occurred.
*
* @param config
* the configuration to launch
* @param bp
* the breakpoint that should cause a suspend event
* @return thread in which the first suspend event occurred
* @throws CoreException
*/
protected AntThread launchToLineBreakpoint(ILaunchConfiguration config, ILineBreakpoint bp) throws CoreException {
DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
waiter.setTimeout(DEFAULT_TIMEOUT);
Object suspendee = launchAndWait(config, waiter);
assertTrue("suspendee was not an AntThread", suspendee instanceof AntThread); //$NON-NLS-1$
AntThread thread = (AntThread) suspendee;
IBreakpoint hit = getBreakpoint(thread);
assertNotNull("suspended, but not by breakpoint", hit); //$NON-NLS-1$
assertTrue("hit un-registered breakpoint", bp.equals(hit)); //$NON-NLS-1$
assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); //$NON-NLS-1$
ILineBreakpoint breakpoint = (ILineBreakpoint) hit;
int lineNumber = breakpoint.getLineNumber();
int stackLine = thread.getTopStackFrame().getLineNumber();
assertTrue("line numbers of breakpoint and stack frame do not match", lineNumber == stackLine); //$NON-NLS-1$
return thread;
}
/**
* Resumes the given thread, and waits for another breakpoint-caused suspend event. Returns the thread in which the suspend event occurs.
*
* @param thread
* thread to resume
* @return thread in which the first suspend event occurs
*/
protected AntThread resume(AntThread thread) throws Exception {
return resume(thread, DEFAULT_TIMEOUT);
}
/**
* Resumes the given thread, and waits for another breakpoint-caused suspend event. Returns the thread in which the suspend event occurs.
*
* @param thread
* thread to resume
* @param timeout
* timeout in ms
* @return thread in which the first suspend event occurs
*/
protected AntThread resume(AntThread thread, int timeout) throws Exception {
DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
waiter.setTimeout(timeout);
thread.resume();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Resumes the given thread, and waits for a suspend event caused by the specified line breakpoint. Returns the thread in which the suspend event
* occurs.
*
* @param thread
* thread to resume
* @return thread in which the first suspend event occurs
* @throws CoreException
*/
protected AntThread resumeToLineBreakpoint(AntThread resumeThread, ILineBreakpoint bp) throws CoreException {
DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
waiter.setTimeout(DEFAULT_TIMEOUT);
resumeThread.resume();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
assertTrue("suspendee was not an AntThread", suspendee instanceof AntThread); //$NON-NLS-1$
AntThread thread = (AntThread) suspendee;
IBreakpoint hit = getBreakpoint(thread);
assertNotNull("suspended, but not by breakpoint", hit); //$NON-NLS-1$
assertTrue("hit un-registered breakpoint", bp.equals(hit)); //$NON-NLS-1$
assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); //$NON-NLS-1$
ILineBreakpoint breakpoint = (ILineBreakpoint) hit;
int lineNumber = breakpoint.getLineNumber();
int stackLine = thread.getTopStackFrame().getLineNumber();
assertTrue("line numbers of breakpoint and stack frame do not match", lineNumber == stackLine); //$NON-NLS-1$
return (AntThread) suspendee;
}
/**
* Resumes the given thread, and waits for the debug target to terminate (i.e. finish/exit the program).
*
* @param thread
* thread to resume
*/
protected void exit(AntThread thread) throws Exception {
DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.TERMINATE, IProcess.class);
waiter.setTimeout(DEFAULT_TIMEOUT);
thread.resume();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
assertNotNull("Program did not terminate.", suspendee); //$NON-NLS-1$
}
/**
* Resumes the given thread, and waits for the associated debug target to terminate.
*
* @param thread
* thread to resume
* @return the terminated debug target
*/
protected AntDebugTarget resumeAndExit(AntThread thread) throws Exception {
DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.TERMINATE, thread.getDebugTarget());
waiter.setTimeout(DEFAULT_TIMEOUT);
thread.resume();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - The program did not terminate"); //$NON-NLS-1$
}
AntDebugTarget target = (AntDebugTarget) suspendee;
assertTrue("program should have exited", target.isTerminated() || target.isDisconnected()); //$NON-NLS-1$
return target;
}
protected IResource getBreakpointResource(String typeName) throws Exception {
IJavaElement element = getJavaProject().findElement(new Path(typeName + ".java")); //$NON-NLS-1$
IResource resource = element.getCorrespondingResource();
if (resource == null) {
resource = getJavaProject().getProject();
}
return resource;
}
/**
* Creates and returns a line breakpoint at the given line number in the given build file
*
* @param lineNumber
* line number
* @param file
* the build file
* @throws CoreException
*/
protected AntLineBreakpoint createLineBreakpoint(int lineNumber, IFile file) throws CoreException {
return new AntLineBreakpoint(file, lineNumber);
}
/**
* Creates and returns a line breakpoint at the given line number in the given build file.
*
* @param lineNumber
* line number
* @param file
* the build file
*/
protected AntLineBreakpoint createLineBreakpoint(int lineNumber, String buildFileName) throws CoreException {
return new AntLineBreakpoint(getIFile(buildFileName), lineNumber);
}
/**
* Terminates the given thread and removes its launch
*/
protected void terminateAndRemove(AntThread thread) throws CoreException {
if (thread != null) {
terminateAndRemove((AntDebugTarget) thread.getDebugTarget());
}
}
/**
* Terminates the given debug target and removes its launch.
*
* NOTE: all breakpoints are removed, all threads are resumed, and then the target is terminated. This avoids defunct processes on linux.
*/
protected void terminateAndRemove(AntDebugTarget debugTarget) throws CoreException {
if (debugTarget != null && !(debugTarget.isTerminated() || debugTarget.isDisconnected())) {
DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.TERMINATE, debugTarget);
removeAllBreakpoints();
IThread[] threads = debugTarget.getThreads();
for (int i = 0; i < threads.length; i++) {
IThread thread = threads[i];
try {
if (thread.isSuspended()) {
thread.resume();
}
}
catch (CoreException e) {
// do nothing
}
}
debugTarget.terminate();
Object event = waiter.waitForEvent();
if (event == null) {
throw new TestAgainException("Retest - Program did not terminate"); //$NON-NLS-1$
}
getLaunchManager().removeLaunch(debugTarget.getLaunch());
}
// ensure event queue is flushed
DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.MODEL_SPECIFIC, this);
DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { new DebugEvent(this, DebugEvent.MODEL_SPECIFIC) });
Object event = waiter.waitForEvent();
if (event == null) {
throw new TestAgainException("Retest - The model specific event was never recieved"); //$NON-NLS-1$
}
}
/**
* Deletes all existing breakpoints
*/
protected void removeAllBreakpoints() throws CoreException {
IBreakpoint[] bps = getBreakpointManager().getBreakpoints();
getBreakpointManager().removeBreakpoints(bps, true);
}
/**
* Returns the first breakpoint the given thread is suspended at, or <code>null</code> if none.
*
* @return the first breakpoint the given thread is suspended at, or <code>null</code> if none
*/
protected IBreakpoint getBreakpoint(IThread thread) {
IBreakpoint[] bps = thread.getBreakpoints();
if (bps.length > 0) {
return bps[0];
}
return null;
}
/**
* Performs a step over in the given stack frame and returns when complete.
*
* @param frame
* stack frame to step in
* @throws DebugException
*/
protected AntThread stepOver(AntStackFrame frame) throws DebugException {
org.eclipse.ant.tests.ui.testplugin.DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.STEP_END);
waiter.setTimeout(DEFAULT_TIMEOUT);
frame.stepOver();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Performs a step over in the given stack frame and expects to hit a breakpoint as part of the step over
*
* @param frame
* stack frame to step in
* @throws DebugException
*/
protected AntThread stepOverToHitBreakpoint(AntStackFrame frame) throws DebugException {
org.eclipse.ant.tests.ui.testplugin.DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.BREAKPOINT);
waiter.setTimeout(DEFAULT_TIMEOUT);
frame.stepOver();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Performs a step into in the given stack frame and returns when complete.
*
* @param frame
* stack frame to step in
*/
protected AntThread stepInto(AntStackFrame frame) throws DebugException {
DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.STEP_END);
waiter.setTimeout(DEFAULT_TIMEOUT);
frame.stepInto();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Performs a step return in the given stack frame and returns when complete.
*
* @param frame
* stack frame to step return from
*/
protected AntThread stepReturn(AntStackFrame frame) throws DebugException {
DebugEventWaiter waiter = new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, AntThread.class, DebugEvent.STEP_END);
waiter.setTimeout(DEFAULT_TIMEOUT);
frame.stepReturn();
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Performs a step into with filters in the given stack frame and returns when complete.
*
* @param frame
* stack frame to step in
*/
protected AntThread stepIntoWithFilters(AntStackFrame frame) throws DebugException {
DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
waiter.setTimeout(DEFAULT_TIMEOUT);
// turn filters on
try {
DebugUITools.setUseStepFilters(true);
frame.stepInto();
}
finally {
// turn filters off
DebugUITools.setUseStepFilters(false);
}
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Performs a step return with filters in the given stack frame and returns when complete.
*
* @param frame
* stack frame to step in
*/
protected AntThread stepReturnWithFilters(AntStackFrame frame) throws DebugException {
DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
waiter.setTimeout(DEFAULT_TIMEOUT);
// turn filters on
try {
DebugUITools.setUseStepFilters(true);
frame.stepReturn();
}
finally {
// turn filters off
DebugUITools.setUseStepFilters(false);
}
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Performs a step over with filters in the given stack frame and returns when complete.
*
* @param frame
* stack frame to step in
*/
protected AntThread stepOverWithFilters(AntStackFrame frame) throws DebugException {
DebugEventWaiter waiter = new DebugElementKindEventWaiter(DebugEvent.SUSPEND, AntThread.class);
waiter.setTimeout(DEFAULT_TIMEOUT);
// turn filters on
try {
DebugUITools.setUseStepFilters(true);
frame.stepOver();
}
finally {
// turn filters off
DebugUITools.setUseStepFilters(false);
}
Object suspendee = waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if (suspendee == null) {
throw new TestAgainException("Retest - Program did not suspend"); //$NON-NLS-1$
}
return (AntThread) suspendee;
}
/**
* Returns the compilation unit with the given name.
*
* @param project
* the project containing the CU
* @param root
* the name of the source folder in the project
* @param pkg
* the name of the package (empty string for default package)
* @param name
* the name of the CU (ex. Something.java)
* @return compilation unit
*/
protected ICompilationUnit getCompilationUnit(IJavaProject project, String root, String pkg, String name) {
IProject p = project.getProject();
IResource r = p.getFolder(root);
return project.getPackageFragmentRoot(r).getPackageFragment(pkg).getCompilationUnit(name);
}
/**
* Sets the current set of Debug / Other preferences to use during each test
*
* @since 3.5
*/
protected void setPreferences() {
IPreferenceStore debugUIPreferences = DebugUIPlugin.getDefault().getPreferenceStore();
String property = System.getProperty("debug.workbenchActivation"); //$NON-NLS-1$
boolean activate = property != null && property.equals("on"); //$NON-NLS-1$
debugUIPreferences.setValue(IDebugPreferenceConstants.CONSOLE_OPEN_ON_ERR, activate);
debugUIPreferences.setValue(IDebugPreferenceConstants.CONSOLE_OPEN_ON_OUT, activate);
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_ACTIVATE_DEBUG_VIEW, activate);
debugUIPreferences.setValue(IDebugUIConstants.PREF_ACTIVATE_WORKBENCH, activate);
}
/*
* (non-Javadoc)
*
* @see junit.framework.TestCase#tearDown()
*/
@Override
protected void tearDown() throws Exception {
if (fEventSet != null) {
fEventSet = null;
}
// reset the options
IPreferenceStore debugUIPreferences = DebugUIPlugin.getDefault().getPreferenceStore();
debugUIPreferences.setToDefault(IDebugPreferenceConstants.CONSOLE_OPEN_ON_ERR);
debugUIPreferences.setToDefault(IDebugPreferenceConstants.CONSOLE_OPEN_ON_OUT);
debugUIPreferences.setToDefault(IInternalDebugUIConstants.PREF_ACTIVATE_DEBUG_VIEW);
debugUIPreferences.setToDefault(IDebugUIConstants.PREF_ACTIVATE_WORKBENCH);
super.tearDown();
}
/*
* (non-Javadoc)
*
* @see junit.framework.TestCase#setUp()
*/
@Override
protected void setUp() throws Exception {
super.setUp();
setPreferences();
DebugUIPlugin.getStandardDisplay().syncExec(new Runnable() {
@Override
public void run() {
IWorkbench workbench = PlatformUI.getWorkbench();
IPerspectiveDescriptor descriptor = workbench.getPerspectiveRegistry().findPerspectiveWithId(IDebugUIConstants.ID_DEBUG_PERSPECTIVE);
workbench.getActiveWorkbenchWindow().getActivePage().setPerspective(descriptor);
}
});
}
}